import java.util.*;

class Son extends Parent{
     Person person = new Person();
     static{
         System.out.println("static son");
     }
     public Son(){
         System.out.println("son");
     }
 }
class Parent{
    Person person = new Person();
    static Person person1 = new Person();
    static {
        System.out.println("static Parent");
    }
    public Parent(){
        System.out.println("parent");
    }

    public static void main(String[] args) {
        new Son();
    }
}
class Person{
    static {
        System.out.println("static Person");
    }
    public Person(){
        System.out.println("person");
    }
}

class Solution {
    public static void main(String[] args) {
        new Solution().findUnsortedSubarray(new int[]{1,2,3,5,4});
    }
    public int findUnsortedSubarray(int[] nums) {
        //1 从中间向两端扩散,左边顺序定义在于，左边每一个都是比右边的更小的，右边顺序在于右边每一个都比其左边的更大
        //2 向左边开始，更新最大最小，如果最小更小，说明失序，这个位置需要重排
        //3 向右边开始，更新最大最小，如果最大更大，说明失序，这个位置需要重排
        //4 由于一开始无法获得右边值，所以无法安全保证左边每一个都是比右边的更小的，需要重新获取一下左边认为不更新的
        //5 另外，由于向左时会取到最左边的值，而可能就是最小值，所以为了排除左边对4步的影响，我们需要判断一下右边是否有更新最小值
        int len = nums.length;
        if(len==1) return 0;
        int start = len/2;
        int left = start, right=start;
        int min = nums[start],max = min;
        int index = start;
        boolean isLeftChange=false,isRightChange = false;
        while(index>0){
            index--;
            //如果有一个值比index
            if(min<nums[index]){
                isLeftChange = true;
                left = index;
            }else{
                min = nums[index];
            }
            if(max<nums[index]){
                max = nums[index];
            }
        }
        index=start;
        while(++index<len){
            if(max>nums[index]){
                right = index;
            }else{
                max = nums[index];
            }
            while(left>0&&nums[left-1]>nums[index]){
                left--;
            }
        }
        return right==left?0:right-left+1;
    }
}